package com.tarena.lbs.basic.service.impl;

import com.alibaba.nacos.common.utils.CollectionUtils;
import com.github.pagehelper.PageInfo;
import com.tarena.lbs.base.protocol.pager.PageResult;
import com.tarena.lbs.basic.dao.mapper.TagMapper;
import com.tarena.lbs.basic.dao.mapper.TagTypeMapper;
import com.tarena.lbs.basic.dao.repository.TagRepository;
import com.tarena.lbs.basic.pojo.param.TagParam;
import com.tarena.lbs.basic.pojo.po.TagLibraryPO;
import com.tarena.lbs.basic.pojo.po.TagLibraryPO1;
import com.tarena.lbs.basic.pojo.po.TagTypePO;
import com.tarena.lbs.basic.pojo.query.TagQuery;
import com.tarena.lbs.basic.pojo.query.TagTypeQuery;
import com.tarena.lbs.basic.pojo.vo.TagLibraryVO;
import com.tarena.lbs.basic.pojo.vo.TagTypeVO;
import com.tarena.lbs.basic.pojo.vo.TagVO;
import com.tarena.lbs.basic.service.TagService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
public class TagServiceImpl implements TagService  {

    @Autowired
    private TagRepository tagRepository;
    @Autowired
    private TagTypeMapper tagTypeMapper;
    @Autowired
    private TagMapper tagMapper;


    @Override
    public Map<String, List<TagVO>> getTagsByType(int i) {

        List<TagTypeVO> tagTypeVOS = tagTypeMapper.selectTagTypeList("用户标签");

        List<TagLibraryPO> tagLibraryPOS = tagMapper.selectListLibraryTag("用户标签");

        Map<String,List<TagVO>> mapVo = assembleTags2Map(tagTypeVOS,tagLibraryPOS);




        //1.从数据层 把素有的文章的标签查询 List
//        List<TagLibraryPO> pos= tagRepository.getTagsBytType(i);
//        log.info("查询的类型:{},查询到的标签有:{}",i,pos);
        //2.单独封装转化
//        Map<String,List<TagVO>> mapVo = assembleTags2Map(pos);
        log.info("封装最终的结果map:{}",mapVo);
        return mapVo;
    }

    private Map<String, List<TagVO>> assembleTags2Map(List<TagLibraryPO> pos) {
        Map<String,List<TagVO>> mapVo=new HashMap<>();
        //2.先筛选(filter)出pos中的所有一级标签 firstLevelPos["美食","旅游"]
        List<TagLibraryPO> firstLevelPos = pos.stream().filter(po -> po.getTagParentId().equals(0)).collect(Collectors.toList());
        //3.对一级标签进行循环
        firstLevelPos.stream().forEach(firstPo->{
            String firstTagName=firstPo.getTagName();//map的key值 美食  旅游
            Integer firstTagId=firstPo.getId();//不就是 二级标签parentId
            //4.如何通过一级标签 对象 拿到属于他的二级标签列表 筛选一下parentId等于当前一级标签id的所有
            //路边摊 网红店  高档酒店
            //日记 传说 趣闻
            List<TagLibraryPO> secondLevelPos =
                    pos.stream().filter(po -> po.getTagParentId().equals(firstTagId)).collect(Collectors.toList());
            //5.将当前的二级标签pos 转化成TagVO格式
            List<TagVO> value = secondLevelPos.stream().map(po -> {
                TagVO vo = new TagVO();
                //一级标签名字
                vo.setTagCategoryName(firstTagName);
                TagLibraryVO voTag = new TagLibraryVO();
                BeanUtils.copyProperties(po, voTag);
                vo.setTagLibraryBO(voTag);
                return vo;
            }).collect(Collectors.toList());
            mapVo.put(firstTagName, value);
        });
        return mapVo;
    }

    private Map<String, List<TagVO>> assembleTags2Map(List<TagTypeVO> tagTypeVOS, List<TagLibraryPO> tagLibraryPOS) {
        Map<String,List<TagVO>> mapVo=new HashMap<>();

        for(TagTypeVO tagTypeVO : tagTypeVOS){
            String firstTagName=tagTypeVO.getTypeName();
            Integer firstTagId=tagTypeVO.getId();
            //6.初始化mapVo的value
            List<TagVO> value=new ArrayList<>();

            for(TagLibraryPO tagLibraryPO : tagLibraryPOS){
                if(tagLibraryPO.getTagParentId().equals(firstTagId)){
                    TagVO vo = new TagVO();
                    //一级标签名字
                    vo.setTagCategoryName(firstTagName);
                    TagLibraryVO voTag = new TagLibraryVO();
                    BeanUtils.copyProperties(tagLibraryPO, voTag);
                    vo.setTagLibraryBO(voTag);
                    value.add(vo);
                }
            }

            mapVo.put(firstTagName,value);
        }

        return mapVo;
    }


    @Override
    public void addTag(TagParam tagParam) {
        TagLibraryPO po=assembleBusinessPO(tagParam);
        UUID uuid = UUID.randomUUID();
        po.setCoding(uuid.toString());
        tagRepository.addTag(po);
    }

    @Override
    public PageResult<TagVO> tagList(TagQuery query) {
        log.debug("开始查询标签列表");
        //定义分页结果对象 pageResult
        PageResult<TagVO> pageResult = new PageResult<>();
        //PageInfo 会返回包含分页信息的包装对象 包括List<TagLibraryPO>+total+pageNum+pageSize+pages
        PageInfo<TagLibraryPO1> pageInfo = tagRepository.list(query);

        // 将分页信息中的页码设置到分页结果对象中
        pageResult.setPageNo(pageInfo.getPageNum());
        // 将分页信息中的每页数量设置到分页结果对象中
        pageResult.setPageSize(pageInfo.getPageSize());
        // 将分页信息中的总记录数设置到分页结果对象中
        pageResult.setTotal(pageInfo.getTotal());

        List<TagLibraryPO1> pos = pageInfo.getList();
        if (pos != null) {
            List<TagVO> vos = pos.stream().map(po -> {
                TagVO vo = new TagVO();
                BeanUtils.copyProperties(po, vo);
                return vo;
            }).collect(Collectors.toList());

            pageResult.setObjects(vos);
        }else {
            pageResult.setObjects(new ArrayList<>());
        }
        return pageResult;
    }

    @Override
    public List<TagTypeVO> tagTypeList(TagTypeQuery query) {
        log.debug("开始查询标签分类服务service");
        List<TagTypePO> pos=tagRepository.tagTypeList(query);
        List<TagTypeVO> vos = pos.stream().map(po -> {
            TagTypeVO vo = new TagTypeVO();
            BeanUtils.copyProperties(po, vo);
            return vo;
        }).collect(Collectors.toList());
        return vos;

    }

    @Override
    public TagVO getTagInfoById(Integer id) {
        log.debug("开始根据标签id查询标签信息");
        TagLibraryPO po=tagRepository.getTagInfoById(id);
        TagVO vo=new TagVO();
        BeanUtils.copyProperties(po,vo);
        return vo;
    }

    @Override
    public void editTag(TagParam param) {
        TagLibraryPO po = assembleBusinessPO(param);
        tagRepository.editTag(po);
    }

    @Override
    public PageResult<TagVO> pageList(TagQuery query){
        PageResult<TagVO> voPage = new PageResult<>();
        PageInfo<TagLibraryPO> pageInfo = tagRepository.pageList(query);

        // 将分页信息中的页码设置到分页结果对象中
        voPage.setPageNo(pageInfo.getPageNum());
        // 将分页信息中的每页数量设置到分页结果对象中
        voPage.setPageSize(pageInfo.getPageSize());
        // 将分页信息中的总记录数设置到分页结果对象中
        voPage.setTotal(pageInfo.getTotal());

        List<TagVO> vos =null;
        List<TagLibraryPO> pos = pageInfo.getList();
        // 判断持久化对象列表是否不为空--不为空则将 po转换成vo
        if (CollectionUtils.isNotEmpty(pos)){
            vos=pos.stream().map(po->{
                TagVO vo = new TagVO();
                BeanUtils.copyProperties(po,vo);
                return vo;
            }).collect(Collectors.toList());
        }
        voPage.setObjects(vos);
        return voPage;
    }

    @Override
    public TagVO getTagInfoByName(String tagName) {
        log.debug("开始根据标签名称查询标签信息");
        TagLibraryPO po=tagRepository.getTagInfoByName(tagName);
        TagVO vo=new TagVO();
        BeanUtils.copyProperties(po,vo);
        return vo;

    }


    private TagLibraryPO assembleBusinessPO(TagParam tagParam) {
        //将param参数转化为PO
        TagLibraryPO po=new TagLibraryPO();
        BeanUtils.copyProperties(tagParam,po);
        //注册时间
        po.setCreateAt(new Date());
        po.setUpdateAt(new Date());
        if (po.getUsageCount()==null){
            po.setUsageCount(0);
        }
        return po;
    }
}
